home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Misc / RZToDoList / Source / ToDoItem.m < prev    next >
Encoding:
Text File  |  1995-06-12  |  9.0 KB  |  421 lines
  1. /* 
  2.  * ToDoItem - implementation of ToDoItem, the basic unit of information 
  3.  *     for the ToDoList program.  The method -adjustPriority implements
  4.  *     the dynamic priority mechanism.
  5.  *
  6.  * You may freely copy, distribute and reuse the code in this example.
  7.  * This code is provided AS IS without warranty of any kind, expressed 
  8.  * or implied, as to its fitness for any particular use.
  9.  *
  10.  * Copyright 1995 Ralph Zazula (rzazula@next.com).  All Rights Reserved.
  11.  *
  12.  */
  13.  
  14. #import "ToDoItem.h"
  15. #import "RZ.h"
  16. #import <appkit/appkit.h>
  17. #import <math.h>
  18.  
  19. typedef struct _toDoItemFlags {
  20. #ifdef __BIG_ENDIAN__
  21.     unsigned int type:8;
  22.     unsigned int private:1;
  23.     unsigned int completed:1;
  24.     unsigned int _RESERVED:22;
  25. #else
  26.     unsigned int _RESERVED:22;
  27.     unsigned int completed:1;
  28.     unsigned int private:1;
  29.     unsigned int type:8;
  30. #endif
  31. } toDoItemFlags;
  32.  
  33. #define _flags ((toDoItemFlags *)_reservedToDoItem1)
  34.  
  35. @implementation ToDoItem
  36.  
  37. + initialize
  38. {
  39.     if([self class] == [ToDoItem class]) {
  40.         [self setVersion:4];
  41.     }
  42.     return self;
  43. }
  44.  
  45. - initSubject:(char *)subj startDate:(long)start dueDate:(long)due
  46.     completeDate:(long)completed type:(char)type isPrivate:(BOOL)privateFlag
  47.     isCompleted:(BOOL)completeFlag data:(char *)buf dataLen:(int)len
  48. {
  49.     if(self = [super init]) {
  50.  
  51.         _flags = (toDoItemFlags *)calloc(1, sizeof(toDoItemFlags));
  52.  
  53.         [self setSubject:subj];
  54.         [self setStartDate:start];
  55.         [self setDueDate:due];
  56.         [self setType:type];
  57.         [self setPrivate:privateFlag];
  58.         
  59.         /* don't want auto-calc of completion so don't use setCompleted: */
  60.         dateCompleted = completed ? completed : 0;
  61.         _flags->completed = completeFlag;
  62.         
  63.         [self setData:buf];
  64.     }
  65.     return self;
  66. }
  67.     
  68. - initFromItem:(id <ToDoItems>)anItem
  69. {
  70.     char *buf;
  71.     int len;
  72.     
  73.     [anItem getData:&buf length:&len];
  74.     
  75.     return [self initSubject:[anItem subject] startDate:[anItem startDate]
  76.                 dueDate:[anItem dueDate] completeDate:[anItem dateCompleted]
  77.                 type:[anItem type] isPrivate:[anItem isPrivate]
  78.                 isCompleted:[anItem isCompleted] data:buf dataLen:len];
  79. }
  80.  
  81. - init
  82. {
  83.     return [self initSubject:NULL startDate:time(NULL) dueDate:(time(NULL)+60)
  84.         completeDate:0 type:TODO_TYPE_NORMAL isPrivate:NO isCompleted:NO 
  85.         data:NULL dataLen:0];
  86. }
  87.  
  88. - free
  89. {
  90.     if(subject) {
  91.         NX_FREE(subject);
  92.         subject = NULL;
  93.     }
  94.     if(data) {
  95.         NX_FREE(data);
  96.         data = NULL;
  97.         dataLen = 0;
  98.     }
  99.     
  100.     free(_flags);
  101.     return [super free];
  102. }
  103.  
  104. - (char *)subject                        { return subject; }
  105. - (long)priority                        { return priority; }
  106. - (long)startDate                        { return startDate; }
  107. - (long)dueDate                        { return dueDate; }
  108. - (long)dateCompleted                { return dateCompleted; }
  109. - (char)type                            { return _flags->type; }
  110. - (BOOL)isPrivate                        { return _flags->private; }
  111. - (BOOL)isCompleted                    { return _flags->completed; }
  112.  
  113. - (const char *)asciiStartDate    
  114. { 
  115.     static char buf[40];
  116.     
  117.     if(!startDate) {
  118.         return NULL;
  119.     }
  120.     
  121.     strftime(buf, 40, "%m/%d/%y", localtime(&startDate));
  122.  
  123.     return buf;
  124. }
  125.  
  126. - (const char *)asciiCompletedDate    
  127. { 
  128.     static char buf[40];
  129.     
  130.     if(!dateCompleted) {
  131.         return NULL;
  132.     }
  133.     
  134.     strftime(buf, 40, "%m/%d/%y", localtime(&dateCompleted));
  135.  
  136.     return buf;
  137. }
  138.  
  139. - (const char *)asciiDueDate        
  140. { 
  141.     static char buf[40];
  142.     
  143.     switch(_flags->type) {
  144.         case TODO_TYPE_NORMAL :
  145.         case TODO_TYPE_APPOINTMENT :
  146.             strftime(buf, 40, "%m/%d/%y", localtime(&dueDate));
  147.             break;
  148.         case TODO_TYPE_HIGHPRIORITY :
  149.             sprintf(buf, "ASAP!");
  150.             break;
  151.         case TODO_TYPE_LOWPRIORITY :
  152.             sprintf(buf, "LATER");
  153.             break;
  154.     }
  155.     
  156.     return buf;
  157. }
  158.  
  159. - getData:(char **)d length:(int *)len
  160. {
  161.     *d = data;
  162.     *len = dataLen;
  163.     return self;
  164. }
  165.  
  166. - setSubject:(const char *)s
  167. {
  168.     subject = RZReplaceStringBuffer(&subject, s);
  169.      return self;
  170. }
  171.  
  172. - setPriority:(long)p
  173. {
  174.     priority = p;
  175.    return self;
  176. }
  177.  
  178. - setStartDate:(long)newDate
  179. {
  180.     startDate = newDate;
  181.    return self;
  182. }
  183.  
  184. - setDueDate:(long)newDate
  185. {
  186.     dueDate = newDate;
  187.     [self adjustPriority];
  188.    return self;
  189. }
  190.  
  191. - setType:(char)newType
  192. {
  193.     _flags->type = newType;
  194.     priority = 0;
  195.  
  196.     return self;
  197. }
  198.  
  199. - setPrivate:(BOOL)flag
  200. {
  201.     _flags->private = flag;
  202.     return self;
  203. }
  204.  
  205. - setCompleted:(BOOL)flag
  206. {
  207.     _flags->completed = flag;
  208.     dateCompleted = flag ? time(NULL) : 0;
  209.     return self;
  210. }
  211.  
  212. - setData:(const char *)d
  213. {
  214.     RZReplaceStringBuffer(&data, d);
  215.     dataLen = data ? strlen(data) + 1 : 0;
  216.    return self;
  217. }
  218.  
  219. - setDataFromText:aText
  220. {
  221.     NXStream *stream;
  222.     BOOL failed = NO;
  223.     
  224.     stream = NXOpenMemory(NULL, 0, NX_READWRITE);
  225.     NX_DURING
  226.     [aText writeRichText:stream];
  227.     NX_HANDLER
  228.     failed = YES;
  229.     NX_ENDHANDLER
  230.     if(!failed) {
  231.         [self setDataFromStream:stream];
  232.         NXCloseMemory(stream, NX_FREEBUFFER);
  233.     }
  234.     
  235.    return self;
  236. }
  237.  
  238. - setDataFromStream:(NXStream *)stream
  239. {
  240.     char *_data;
  241.     int _dataLen, _maxLen;
  242.     
  243.     NXGetMemoryBuffer(stream, &_data, &_dataLen, &_maxLen);
  244.     [self setData:_data];
  245.     
  246.    return self;
  247. }
  248.  
  249. - writeToStream:(NXStream *)stream
  250. {
  251.     static id dummyText = nil;
  252.     
  253.     NXPrintf(stream, "Subject: %s\n",[self subject]);
  254.     switch(_flags->type) {
  255.         case TODO_TYPE_NORMAL :
  256.             NXPrintf(stream, "Type: Normal\n");
  257.             break;
  258.             
  259.         case TODO_TYPE_APPOINTMENT :
  260.             NXPrintf(stream, "Type: Appointment\n");
  261.             break;
  262.             
  263.         case TODO_TYPE_LOWPRIORITY : 
  264.             NXPrintf(stream, "Type: Low Priority\n");
  265.             break;
  266.             
  267.         case TODO_TYPE_HIGHPRIORITY :
  268.             NXPrintf(stream, "Type: High Priority\n");
  269.             break;
  270.     }
  271.     NXPrintf(stream, "Created: %s\n",[self asciiStartDate]);
  272.     NXPrintf(stream, "Due on: %s\n",[self asciiDueDate]);
  273.     if(_flags->completed) {
  274.         NXPrintf(stream, "Completed: %s\n",[self asciiCompletedDate]);
  275.     }
  276.     NXPrintf(stream, "\n");
  277.     if(dataLen) {
  278.         NXStream *_stream;
  279.         if(!dummyText) {
  280.             dummyText = [[Text alloc] init];
  281.         }
  282.         _stream = NXOpenMemory(NULL, 0, NX_READWRITE);
  283.         NXWrite(_stream, data, dataLen);
  284.         NXSeek(_stream, 0, NX_FROMSTART);
  285.         [dummyText readRichText:_stream];
  286.         NXCloseMemory(_stream, NX_FREEBUFFER);
  287.         [dummyText writeText:stream];
  288.     }
  289.     return self;
  290. }
  291.  
  292. #define LOW_PRIORITY_BASE 0
  293. #define LOW_PRIORITY_SIZE 256
  294. #define LOW_PRIORITY_MAX (LOW_PRIORITY_BASE + LOW_PRIORITY_SIZE)
  295. #define NORMAL_PRIORITY_BASE (LOW_PRIORITY_MAX + 1)
  296. #define NORMAL_PRIORITY_SIZE 512
  297. #define NORMAL_PRIORITY_MAX (NORMAL_PRIORITY_BASE + NORMAL_PRIORITY_SIZE)
  298. #define HIGH_PRIORITY_BASE (NORMAL_PRIORITY_MAX + 1)
  299. #define HIGH_PRIORITY_SIZE 256
  300. #define HIGH_PRIORITY_MAX (HIGH_PRIORITY_BASE + HIGH_PRIORITY_SIZE)
  301.  
  302. #define ONE_DAY (60*60*24)
  303. #define ONE_YEAR (60*60*24*365)
  304. #define OLDEST_ITEM ONE_YEAR
  305.     
  306. - adjustPriority
  307. /* 
  308.  * priority quantizer - I've decided to quantize priorities in the
  309.  * range 0 - 1023 (if you have more than 1K of stuff to do, you're
  310.  * in trouble :-)  The priority space is divided into three regions:
  311.  *     0 - 255        LOW PRIORITY ITEMS
  312.  *        256 - 767    NORMAL PRIORITY ITEMS
  313.  *        768 - 1023     HIGH PRIORITY ITEMS
  314.  */
  315. {
  316.     long age = time(NULL) - startDate;
  317.     long deadline = dueDate - time(NULL);
  318.     
  319.     if(_flags->completed) {
  320.         priority = -dateCompleted;
  321.         return self;
  322.     }
  323.         
  324.     switch(_flags->type) {
  325.         case TODO_TYPE_LOWPRIORITY : 
  326.             /* accrue priority over time but never get above LOW_PRIORITY_MAX */
  327.             priority = LOW_PRIORITY_BASE + 
  328.                 LOW_PRIORITY_SIZE*((float)age/(float)OLDEST_ITEM);
  329.             priority = MIN(priority, LOW_PRIORITY_MAX);
  330.             break;
  331.             
  332.         case TODO_TYPE_NORMAL :
  333.             /* increase priority as we get nearer the deadline */
  334.             if(deadline > 0) {
  335.                 /* quantize the time until the deadline */
  336.                 priority = NORMAL_PRIORITY_MAX - 
  337.                     NORMAL_PRIORITY_SIZE*((float)deadline/(float)OLDEST_ITEM);
  338.             } else {
  339.                 /* past the due date, make max priority */
  340.                 priority = NORMAL_PRIORITY_MAX;
  341.             }
  342.             priority = MIN(priority, NORMAL_PRIORITY_MAX);
  343.             break;
  344.  
  345.         case TODO_TYPE_HIGHPRIORITY :
  346.             /* accrue priority over time but never get above HIGH_PRIORITY_MAX */
  347.             priority = HIGH_PRIORITY_BASE + 
  348.                 HIGH_PRIORITY_SIZE*((float)age/(float)OLDEST_ITEM);
  349.             priority = MIN(priority, HIGH_PRIORITY_MAX);
  350.             break;
  351.  
  352.         case TODO_TYPE_APPOINTMENT :
  353.             /* drop into an appropriate slot based on the appointment date */
  354.             if(deadline > 10*ONE_DAY) {
  355.                 priority = LOW_PRIORITY_MAX;
  356.             } else if(deadline < 2*ONE_DAY) {
  357.                 priority = HIGH_PRIORITY_MAX;
  358.             } else {
  359.                 priority = NORMAL_PRIORITY_MAX;
  360.             }
  361.             break;
  362.  
  363.     }
  364.         
  365.     return self;
  366. }
  367.  
  368. - awake
  369. {
  370.     [self adjustPriority];
  371.     return self;
  372. }
  373.  
  374. - read:(NXTypedStream *)ts
  375. {
  376.     [super read:ts];
  377.     _flags = (toDoItemFlags *)calloc(1,sizeof(toDoItemFlags));
  378.     
  379.     switch(NXTypedStreamClassVersion(ts, [[self class] name])) {
  380.         case 4 :
  381.             NXReadTypes(ts, "*llll*iI",
  382.                 &subject, &priority, &startDate, &dueDate, &dateCompleted, 
  383.                 &data, &dataLen, _flags);
  384.             break;    
  385.             
  386.         case 3 :
  387.             NXReadTypes(ts, "*llll*ii",
  388.                 &subject, &priority, &startDate, &dueDate, &dateCompleted, 
  389.                 &data, &dataLen, _flags);
  390.             break;    
  391.             
  392.         case 2 :
  393.             NXReadTypes(ts, "*lll*ii",
  394.                 &subject, &priority, &startDate, &dueDate, &data, &dataLen, _flags);
  395.             break;    
  396.             
  397.         case 1 :
  398.             NXReadTypes(ts, "*lll*ic",
  399.                 &subject, &priority, &startDate, &dueDate, &data, &dataLen, &_flags->type);
  400.             break;    
  401.             
  402.         case 0 :
  403.             NXReadTypes(ts, "*lll*i",
  404.                 &subject, &priority, &startDate, &dueDate, &data, &dataLen);
  405.             break;
  406.     }
  407.     
  408.     return self;
  409. }
  410.  
  411. - write:(NXTypedStream *)ts
  412. {
  413.     [super write:ts];
  414.     NXWriteTypes(ts, "*llll*iI",
  415.         &subject, &priority, &startDate, &dueDate, &dateCompleted, 
  416.         &data, &dataLen, _flags);
  417.     return self;
  418. }
  419.  
  420. @end
  421.